home *** CD-ROM | disk | FTP | other *** search
/ Visual Basic Source Code / Visual Basic Source Code.iso / vbsource / vbdatabs / strutil.cpp < prev    next >
C/C++ Source or Header  |  1999-03-29  |  8KB  |  246 lines
  1. // ------------------------------- //
  2. // -------- Start of File -------- //
  3. // ------------------------------- //
  4. // ----------------------------------------------------------- // 
  5. // C++ Source Code File Name: strutil.cpp 
  6. // Compiler Used: MSVC40, DJGPP 2.7.2.1, GCC 2.7.2.1, HP CPP 10.24
  7. // Produced By: Doug Gaer 
  8. // File Creation Date: 12/16/1997 
  9. // Date Last Modified: 03/30/1999
  10. // Copyright (c) 1997 Douglas M. Gaer
  11. // ----------------------------------------------------------- // 
  12. // ------------- Program Description and Details ------------- // 
  13. // ----------------------------------------------------------- // 
  14. /*
  15. The VBD C++ classes are copyright (c) 1997, by Douglas M. Gaer.
  16. All those who put this code or its derivatives in a commercial
  17. product MUST mention this copyright in their documentation for
  18. users of the products in which this code or its derivative
  19. classes are used. Otherwise, you have the freedom to redistribute
  20. verbatim copies of this source code, adapt it to your specific
  21. needs, or improve the code and release your improvements to the
  22. public provided that the modified files carry prominent notices
  23. stating that you changed the files and the date of any change.
  24.  
  25. THIS SOFTWARE IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND.
  26. THE ENTIRE RISK OF THE QUALITY AND PERFORMANCE OF THIS SOFTWARE
  27. IS WITH YOU. SHOULD ANY ELEMENT OF THIS SOFTWARE PROVE DEFECTIVE,
  28. YOU WILL ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR, OR
  29. CORRECTION.
  30.  
  31. General string utility functions use to manipulate and parse
  32. null-terminated character strings.
  33. */
  34. // ----------------------------------------------------------- // 
  35. #include <string.h>
  36. #include <ctype.h>
  37. #include "strutil.h"
  38.  
  39. // This include file is no longer used
  40. // #include "os_type.h"
  41.  
  42. // Enable this macro DOS and Windows applications
  43. // #ifndef __DOS__
  44. // #define __DOS__
  45. // #endif 
  46.  
  47. // Enable this macro for Generic Unix applications
  48. // #ifndef __UNIX__
  49. // #define __UNIX__
  50. // #endif 
  51.  
  52. char *StringCat(const char *s1, const char *s2, const char *s3)
  53. {
  54.   int len = strlen(s1) + strlen(s2) + strlen(s3);
  55.   char *comp = new char[len];
  56.   comp[len] = '\0';
  57.   strcpy(comp, s1);
  58.   strcat(comp, s2);
  59.   strcat(comp, s3);
  60.   return comp;
  61. }
  62.  
  63. char *StringCat(char *s1, char *s2, char *s3)
  64. {
  65.   int len = strlen(s1) + strlen(s2) + strlen(s3);
  66.   char *comp = new char[len];
  67.   comp[len] = '\0';
  68.   strcpy(comp, s1);
  69.   strcat(comp, s2);
  70.   strcat(comp, s3);
  71.   return comp;
  72. }
  73.  
  74. int parse(char *string, char words[MAXWORDS][MAXWORDLENGTH],
  75.       int*numwords, char sepchar)
  76. // General purpose string parser
  77. {
  78.   int i = 0;
  79.   char newword[MAXWORDLENGTH];
  80.   *numwords = 0;
  81.  
  82.   // First skip over leading blanks. Stop if an ASCII NULL is seen
  83.   while (1) {
  84.     if (*string == '\0') return 0;
  85.     if (*string != ' ') break;
  86.     string++;
  87.   }
  88.   
  89.   while(1) {
  90.     // Check to see if there is room for another word in the array
  91.     if(*numwords == MAXWORDS) return 1;
  92.  
  93.     i = 0;
  94.     while (i < MAXWORDLENGTH) {
  95.       if(*string == 0 || *string == sepchar) break;
  96.       newword[i] = *string;
  97.       string++;
  98.       i++;
  99.     }
  100.     newword[i] = 0;   // Ensure an ASCII null at end of newword. 
  101.     strcpy (words[*numwords], newword);  // Install into array 
  102.     (*numwords)++;
  103.     
  104.     // If stopped by an ASCII NULL above, exit loop
  105.     if(*string == 0) break;
  106.     
  107.     string++;
  108.     if(*string == 0) break;
  109.   }
  110.   return 0;
  111. }
  112.  
  113. int CaseICmp(const char *s1, const char *s2)
  114. // Compare two strings without regard to the case of the letters
  115. {
  116. #if defined (__DOS__) 
  117.   // Case-insensitive compare for most DOS/Windows Compilers
  118.   return stricmp(s1, s2);
  119. #elif defined(__VISUALC__) || ( defined(__MWERKS__) && defined(__INTEL__) )
  120.   return stricmp(s1, s2);
  121. #elif defined(__SC__)
  122.   return stricmp(s1, s2);
  123. #elif defined(__SALFORDC__)
  124.   return stricmp(s1, s2);
  125. #elif defined(__BORLANDC__)
  126.   return stricmp(s1, s2);
  127. #elif defined(__WATCOMC__)
  128.   return stricmp(s1, s2);
  129. #elif defined (__UNIX__) || defined(__GNUWIN32__)
  130.   // Case-insensitive compare for most UNIX Compilers
  131.   return strcasecmp(s1, s2);
  132. #else
  133.     register char c1, c2;
  134.     do {
  135.       c1 = tolower(*s1++);
  136.       c2 = tolower(*s2++);
  137.     } while ( c1 && (c1 == c2) );
  138.  
  139.     return c1 - c2;
  140. #endif 
  141. }
  142.  
  143. int CaseICmp(char *s1, char *s2)
  144. // Compare two strings without regard to the case of the letters
  145. {
  146. #if defined (__DOS__) 
  147.   // Case-insensitive compare for most DOS/Windows Compilers
  148.   return stricmp(s1, s2);
  149. #elif defined(__VISUALC__) || ( defined(__MWERKS__) && defined(__INTEL__) )
  150.   return stricmp(s1, s2);
  151. #elif defined(__SC__)
  152.   return stricmp(s1, s2);
  153. #elif defined(__SALFORDC__)
  154.   return stricmp(s1, s2);
  155. #elif defined(__BORLANDC__)
  156.   return stricmp(s1, s2);
  157. #elif defined(__WATCOMC__)
  158.   return stricmp(s1, s2);
  159. #elif defined (__UNIX__) || defined(__GNUWIN32__)
  160.   // Case-insensitive compare for most UNIX Compilers
  161.   return strcasecmp(s1, s2);
  162. #else
  163.     register char c1, c2;
  164.     do {
  165.       c1 = tolower(*s1++);
  166.       c2 = tolower(*s2++);
  167.     } while ( c1 && (c1 == c2) );
  168.  
  169.     return c1 - c2;
  170. #endif 
  171. }
  172.  
  173. int FindMatch(const char *str, const char *p, unsigned offset)
  174. // Finds pattern "p" in string "s" starting at specified offset.
  175. // Returns index of first occurrence of matching pattern or -1
  176. // if no match is found.
  177. {
  178.   char *Start = (char *)str + offset; // Start of string data
  179.   char *Next = Start;                 // Next string element
  180.   char *Pattern = (char *)p;          // Next pattern element
  181.   unsigned i = offset;                // Next string element index
  182.   unsigned Len = strlen(str);
  183.   
  184.   while(i < Len && *Pattern) {
  185.     if (*Next == *Pattern) {
  186.       Pattern++;
  187.       if(*Pattern == 0) return i; // Pattern was found
  188.       Next++;
  189.     }
  190.     else {
  191.       i++;
  192.       Start++;
  193.       Next = Start;
  194.       Pattern = (char *)p;
  195.     }
  196.   }
  197.   return NOMATCH; // No match was found
  198. }
  199.  
  200. int FindMatch(char *str, char *p, unsigned offset)
  201. // Finds pattern "p" in string "s" starting at specified offset.
  202. // Returns index of first occurrence of matching pattern or -1
  203. // if no match is found.
  204. {
  205.   return FindMatch((const char *)str, (const char *)p, offset);
  206. }
  207.  
  208. int IFindMatch(const char *str, const char *p, unsigned offset)
  209. // Finds pattern "p" in string "s" starting at specified offset
  210. // using a case insensitive compare. Returns index of first 
  211. // occurrence of matching pattern or -1 if no match is found.
  212. {
  213.   char *Start = (char *)str + offset; // Start of string data
  214.   char *Next = Start;                 // Next string element
  215.   char *Pattern = (char *)p;          // Next pattern element
  216.   unsigned i = offset;                // Next string element index
  217.   unsigned Len = strlen(str);
  218.   
  219.   while(i < Len && *Pattern) {
  220.     if (tolower(*Next) == tolower(*Pattern)) {
  221.       Pattern++;
  222.       if(*Pattern == 0) return i; // Pattern was found
  223.       Next++;
  224.     }
  225.     else {
  226.       i++;
  227.       Start++;
  228.       Next = Start;
  229.       Pattern = (char *)p;
  230.     }
  231.   }
  232.   return NOMATCH; // No match was found
  233. }
  234.  
  235. int IFindMatch(char *str, char *p, unsigned offset)
  236. // Finds pattern "p" in string "s" starting at specified offset
  237. // using a case insensitive compare. Returns index of first 
  238. // occurrence of matching pattern or -1 if no match is found.
  239. {
  240.   return IFindMatch((const char *)str, (const char *)p, offset);
  241. }
  242. // ----------------------------------------------------------- //
  243. // ------------------------------- //
  244. // --------- End of File --------- //
  245. // ------------------------------- //
  246.